--- /dev/null
+Abseil for Debian
+-----------------
+
+libabsl-dev installs a number of files to 'internal' directories. In general,
+your project should not directly include any files from these directories; they
+may change without warning. If you think you need something from one of those
+files, please report a bug with reportbug(1).
+
+ -- Benjamin Barenblat <bbaren@debian.org> Thu, 07 May 2020 11:35:28 -0400
--- /dev/null
+abseil (0~20200923.3-2) unstable; urgency=medium
+
+ * Correct string formatting on POWER.
+
+ -- Benjamin Barenblat <bbaren@debian.org> Tue, 09 Feb 2021 14:41:06 -0500
+
+abseil (0~20200923.3-1) unstable; urgency=medium
+
+ * New upstream release.
+ * Correct endianness issues in hash functions and RNG.
+
+ -- Benjamin Barenblat <bbaren@debian.org> Mon, 08 Feb 2021 15:04:52 -0500
+
+abseil (0~20200923.2-3) unstable; urgency=medium
+
+ * Fix some issues in unit tests.
+ * Re-disable unit tests on most platforms until they’re working
+ everywhere.
+
+ -- Benjamin Barenblat <bbaren@debian.org> Sun, 31 Jan 2021 15:13:51 -0500
+
+abseil (0~20200923.2-2) unstable; urgency=medium
+
+ * Reenable unit tests.
+
+ -- Benjamin Barenblat <bbaren@debian.org> Tue, 01 Dec 2020 12:37:56 -0500
+
+abseil (0~20200923.2-1) unstable; urgency=medium
+
+ * New upstream release.
+ * Fix build on hppa via patch. (Closes: #971768)
+ * Link libatomic where necessary to prevent issues with load-time
+ symbol resolution. (Closes: #973492)
+
+ -- Benjamin Barenblat <bbaren@debian.org> Fri, 06 Nov 2020 16:51:39 -0500
+
+abseil (0~20200923.1-1) unstable; urgency=medium
+
+ * New upstream release.
+
+ -- Benjamin Barenblat <bbaren@debian.org> Mon, 12 Oct 2020 12:40:50 -0400
+
+abseil (0~20200923-2) unstable; urgency=medium
+
+ * Release for unstable.
+
+ -- Benjamin Barenblat <bbaren@debian.org> Tue, 06 Oct 2020 10:00:02 -0400
+
+abseil (0~20200923-1) experimental; urgency=medium
+
+ * New upstream release.
+
+ -- Benjamin Barenblat <bbaren@debian.org> Fri, 25 Sep 2020 17:57:31 -0400
+
+abseil (0~20200225.2-4) unstable; urgency=medium
+
+ * Fix "autopkgtest needs update for new version of cmake: warning on
+ stderr" by applying a patch from upstream. (Closes: #970333)
+
+ -- Benjamin Barenblat <bbaren@debian.org> Mon, 14 Sep 2020 17:40:05 -0400
+
+abseil (0~20200225.2-3) unstable; urgency=medium
+
+ * Replace symbols file with shlibs infrastructure. (Closes: #966183)
+
+ -- Benjamin Barenblat <bbaren@debian.org> Fri, 24 Jul 2020 09:42:03 -0400
+
+abseil (0~20200225.2-2) unstable; urgency=medium
+
+ * Rebuild for unstable.
+ * Rework symbols file using pkg-kde-tools for increased robustness.
+ * Avoid SSSE3 on amd64 and SSE2 on i386 for greater processor
+ compatibility.
+
+ -- Benjamin Barenblat <bbaren@debian.org> Thu, 23 Jul 2020 17:23:57 -0400
+
+abseil (0~20200225.2-1) experimental; urgency=medium
+
+ * Initial release. (Closes: #888705)
+
+ -- Benjamin Barenblat <bbaren@debian.org> Thu, 18 Jun 2020 16:27:49 -0400
--- /dev/null
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+Source: abseil
+Priority: optional
+Maintainer: Benjamin Barenblat <bbaren@debian.org>
+Build-Depends:
+ cmake (>= 3.5),
+ debhelper-compat (= 12),
+ googletest (>= 1.10.0.20200926) [amd64],
+Rules-Requires-Root: no
+Standards-Version: 4.5.1
+Section: libs
+Homepage: https://abseil.io/
+Vcs-Browser: https://salsa.debian.org/debian/abseil
+Vcs-Git: https://salsa.debian.org/debian/abseil.git
+Description: extensions to the C++ standard library
+ Abseil is an open-source collection of C++ library code designed to augment the
+ C++ standard library. The Abseil library code is collected from Google's C++
+ codebase and has been extensively tested and used in production. In some cases,
+ Abseil provides pieces missing from the C++ standard; in others, Abseil
+ provides alternatives to the standard for special needs.
+
+Package: libabsl-dev
+Architecture: any
+Multi-Arch: same
+Section: libdevel
+Depends:
+ libabsl20200923 (= ${binary:Version}),
+ ${misc:Depends},
+Recommends: cmake (>= 2.6), g++ (>= 4.7)
+Description: ${source:Synopsis} (development files)
+ ${source:Extended-Description}
+ .
+ This package contains header files and other data necessary for developing with
+ Abseil.
+
+Package: libabsl20200923
+Architecture: any
+Multi-Arch: same
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Description: ${source:Synopsis}
+ ${source:Extended-Description}
+ .
+ This package contains Abseil's shared libraries.
--- /dev/null
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: Abseil
+Upstream-Contact: abseil-io@googlegroups.com
+Source: https://github.com/abseil/abseil-cpp/
+Copyright: 2017 The Abseil Authors
+License: Apache-2.0
+
+Files: *
+Copyright:
+ 2000-2017 Google Inc.
+ 2017-2020 The Abseil Authors
+License: Apache-2.0
+
+Files: debian/*
+Copyright: 2020 Google LLC
+License: Apache-2.0
+
+Files: debian/patches/fix-hppa.diff
+Copyright: 2020 John David Anglin <dave.anglin@bell.net>
+License: Apache-2.0
+
+License: Apache-2.0
+ Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+ this file except in compliance with the License. You may obtain a copy of the
+ License at
+ .
+ https://www.apache.org/licenses/LICENSE-2.0
+ .
+ Unless required by applicable law or agreed to in writing, software distributed
+ under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations under the License.
+ .
+ On Debian systems, the complete text of the Apache License, Version 2.0, can be
+ found in "/usr/share/common-licenses/Apache-2.0".
--- /dev/null
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+[DEFAULT]
+upstream-tag = 20200923.3
--- /dev/null
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+usr/include/absl
+usr/lib/*/*.a
+usr/lib/*/*.so
+usr/lib/*/cmake
--- /dev/null
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+usr/lib/*/libabsl_bad_any_cast_impl.so.*
+usr/lib/*/libabsl_bad_optional_access.so.*
+usr/lib/*/libabsl_bad_variant_access.so.*
+usr/lib/*/libabsl_base.so.*
+usr/lib/*/libabsl_city.so.*
+usr/lib/*/libabsl_civil_time.so.*
+usr/lib/*/libabsl_cord.so.*
+usr/lib/*/libabsl_debugging_internal.so.*
+usr/lib/*/libabsl_demangle_internal.so.*
+usr/lib/*/libabsl_examine_stack.so.*
+usr/lib/*/libabsl_exponential_biased.so.*
+usr/lib/*/libabsl_failure_signal_handler.so.*
+usr/lib/*/libabsl_flags.so.*
+usr/lib/*/libabsl_flags_commandlineflag.so.*
+usr/lib/*/libabsl_flags_commandlineflag_internal.so.*
+usr/lib/*/libabsl_flags_config.so.*
+usr/lib/*/libabsl_flags_internal.so.*
+usr/lib/*/libabsl_flags_marshalling.so.*
+usr/lib/*/libabsl_flags_parse.so.*
+usr/lib/*/libabsl_flags_private_handle_accessor.so.*
+usr/lib/*/libabsl_flags_program_name.so.*
+usr/lib/*/libabsl_flags_reflection.so.*
+usr/lib/*/libabsl_flags_usage.so.*
+usr/lib/*/libabsl_flags_usage_internal.so.*
+usr/lib/*/libabsl_graphcycles_internal.so.*
+usr/lib/*/libabsl_hash.so.*
+usr/lib/*/libabsl_hashtablez_sampler.so.*
+usr/lib/*/libabsl_int128.so.*
+usr/lib/*/libabsl_leak_check.so.*
+usr/lib/*/libabsl_leak_check_disable.so.*
+usr/lib/*/libabsl_log_severity.so.*
+usr/lib/*/libabsl_malloc_internal.so.*
+usr/lib/*/libabsl_periodic_sampler.so.*
+usr/lib/*/libabsl_random_distributions.so.*
+usr/lib/*/libabsl_random_internal_distribution_test_util.so.*
+usr/lib/*/libabsl_random_internal_platform.so.*
+usr/lib/*/libabsl_random_internal_pool_urbg.so.*
+usr/lib/*/libabsl_random_internal_randen.so.*
+usr/lib/*/libabsl_random_internal_randen_hwaes.so.*
+usr/lib/*/libabsl_random_internal_randen_hwaes_impl.so.*
+usr/lib/*/libabsl_random_internal_randen_slow.so.*
+usr/lib/*/libabsl_random_internal_seed_material.so.*
+usr/lib/*/libabsl_random_seed_gen_exception.so.*
+usr/lib/*/libabsl_random_seed_sequences.so.*
+usr/lib/*/libabsl_raw_hash_set.so.*
+usr/lib/*/libabsl_raw_logging_internal.so.*
+usr/lib/*/libabsl_scoped_set_env.so.*
+usr/lib/*/libabsl_spinlock_wait.so.*
+usr/lib/*/libabsl_stacktrace.so.*
+usr/lib/*/libabsl_status.so.*
+usr/lib/*/libabsl_statusor.so.*
+usr/lib/*/libabsl_str_format_internal.so.*
+usr/lib/*/libabsl_strerror.so.*
+usr/lib/*/libabsl_strings.so.*
+usr/lib/*/libabsl_strings_internal.so.*
+usr/lib/*/libabsl_symbolize.so.*
+usr/lib/*/libabsl_synchronization.so.*
+usr/lib/*/libabsl_throw_delegate.so.*
+usr/lib/*/libabsl_time.so.*
+usr/lib/*/libabsl_time_zone.so.*
--- /dev/null
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+libabsl20200923: no-symbols-control-file usr/lib/*/libabsl_*
+libabsl20200923: package-name-doesnt-match-sonames libabsl-*
+libabsl20200923: spelling-error-in-binary usr/lib/*/libabsl_flags_usage_internal.so* helpfull helpful
--- /dev/null
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+#
+libabsl_bad_any_cast_impl 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_bad_optional_access 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_bad_variant_access 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_base 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_city 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_civil_time 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_cord 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_debugging_internal 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_demangle_internal 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_examine_stack 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_exponential_biased 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_failure_signal_handler 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_flags 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_flags_commandlineflag 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_flags_commandlineflag_internal 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_flags_config 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_flags_internal 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_flags_marshalling 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_flags_parse 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_flags_private_handle_accessor 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_flags_program_name 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_flags_reflection 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_flags_usage 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_flags_usage_internal 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_graphcycles_internal 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_hash 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_hashtablez_sampler 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_int128 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_leak_check 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_leak_check_disable 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_log_severity 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_malloc_internal 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_periodic_sampler 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_random_distributions 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_random_internal_distribution_test_util 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_random_internal_platform 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_random_internal_pool_urbg 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_random_internal_randen 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_random_internal_randen_hwaes 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_random_internal_randen_hwaes_impl 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_random_internal_randen_slow 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_random_internal_seed_material 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_random_seed_gen_exception 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_random_seed_sequences 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_raw_hash_set 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_raw_logging_internal 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_scoped_set_env 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_spinlock_wait 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_stacktrace 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_status 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_statusor 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_str_format_internal 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_strerror 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_strings 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_strings_internal 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_symbolize 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_synchronization 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_throw_delegate 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_time 20200923 libabsl20200923 (>= 0~20200923-1)
+libabsl_time_zone 20200923 libabsl20200923 (>= 0~20200923-1)
--- /dev/null
+From: Benjamin Barenblat <bbaren@google.com>
+Subject: Set package configuration options
+Forwarded: not-needed
+
+Configure Abseil for Debian.
+
+ - Set the SONAME appropriately.
+
+ - To minimize the possibility of future ABI breakage, treat absl::any,
+ absl::optional, absl::string_view, and absl::variant as their own types
+ (rather than aliases for the std:: versions), and compile everything in an
+ inline namespace.
+
+ - Enable upstream's hardened build mode.
+
+ - Disable Intel SSE2 on i386, since Debian supports some i386 processors
+ without that extension. Keep it enabled on amd64, since all amd64 processors
+ have it.
+
+ - Disable Intel SSSE3 entirely, since no i386 processor supports it and Debian
+ supports amd64 processors without it.
+
+--- a/CMake/AbseilHelpers.cmake
++++ b/CMake/AbseilHelpers.cmake
+@@ -217,6 +217,9 @@
+ OUTPUT_NAME "absl_${_NAME}"
+ )
+ endif()
++
++ set_property(TARGET ${_NAME} PROPERTY SOVERSION 20200923)
++ set_property(TARGET ${_NAME} PROPERTY VERSION "20200923.0.1")
+ else()
+ # Generating header-only library
+ add_library(${_NAME} INTERFACE)
+--- a/absl/base/options.h
++++ b/absl/base/options.h
+@@ -100,7 +100,7 @@
+ // User code should not inspect this macro. To check in the preprocessor if
+ // absl::any is a typedef of std::any, use the feature macro ABSL_USES_STD_ANY.
+
+-#define ABSL_OPTION_USE_STD_ANY 2
++#define ABSL_OPTION_USE_STD_ANY 0
+
+
+ // ABSL_OPTION_USE_STD_OPTIONAL
+@@ -127,7 +127,7 @@
+ // absl::optional is a typedef of std::optional, use the feature macro
+ // ABSL_USES_STD_OPTIONAL.
+
+-#define ABSL_OPTION_USE_STD_OPTIONAL 2
++#define ABSL_OPTION_USE_STD_OPTIONAL 0
+
+
+ // ABSL_OPTION_USE_STD_STRING_VIEW
+@@ -154,7 +154,7 @@
+ // absl::string_view is a typedef of std::string_view, use the feature macro
+ // ABSL_USES_STD_STRING_VIEW.
+
+-#define ABSL_OPTION_USE_STD_STRING_VIEW 2
++#define ABSL_OPTION_USE_STD_STRING_VIEW 0
+
+ // ABSL_OPTION_USE_STD_VARIANT
+ //
+@@ -180,7 +180,7 @@
+ // absl::variant is a typedef of std::variant, use the feature macro
+ // ABSL_USES_STD_VARIANT.
+
+-#define ABSL_OPTION_USE_STD_VARIANT 2
++#define ABSL_OPTION_USE_STD_VARIANT 0
+
+
+ // ABSL_OPTION_USE_INLINE_NAMESPACE
+@@ -206,7 +206,7 @@
+ // allowed.
+
+ #define ABSL_OPTION_USE_INLINE_NAMESPACE 1
+-#define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_2020_09_23
++#define ABSL_OPTION_INLINE_NAMESPACE_NAME debian1
+
+ // ABSL_OPTION_HARDENED
+ //
+@@ -233,6 +233,6 @@
+ // checks enabled by this option may abort the program in a different way and
+ // log additional information when `NDEBUG` is not defined.
+
+-#define ABSL_OPTION_HARDENED 0
++#define ABSL_OPTION_HARDENED 1
+
+ #endif // ABSL_BASE_OPTIONS_H_
+--- a/absl/container/internal/have_sse.h
++++ b/absl/container/internal/have_sse.h
+@@ -17,22 +17,14 @@
+ #define ABSL_CONTAINER_INTERNAL_HAVE_SSE_H_
+
+ #ifndef ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+-#if defined(__SSE2__) || \
+- (defined(_MSC_VER) && \
+- (defined(_M_X64) || (defined(_M_IX86) && _M_IX86_FP >= 2)))
++#if defined(__x86_64__) || (defined(_MSC_VER) && defined(_M_X64))
+ #define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 1
+ #else
+ #define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 0
+ #endif
+ #endif
+
+-#ifndef ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
+-#ifdef __SSSE3__
+-#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 1
+-#else
+ #define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 0
+-#endif
+-#endif
+
+ #if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 && \
+ !ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
--- /dev/null
+From: Benjamin Barenblat <bbaren@google.com>
+Subject: Ignore missing CPU frequency on more architectures
+Forwarded: yes
+Applied-Upstream: https://github.com/abseil/abseil-cpp/commit/1918ad2ae38aa32c74b558b322479a8efdd76363
+
+Linux on MIPS, PA-RISC, RISC-V, and SystemZ doesn’t expose the nominal CPU
+frequency via /sys, so don’t worry if `NominalCPUFrequency` returns 1.0 on those
+platforms.
+
+Some POWER machines expose the CPU frequency; others do not. Since we can’t
+predict which type of machine the tests will run on, simply disable testing for
+`NominalCPUFrequency` on POWER.
+
+The author works at Google. Upstream applied this patch as Piper revision
+347079873 and exported it to GitHub; the Applied-Upstream URL above points to
+the exported commit.
+
+--- a/absl/base/internal/sysinfo_test.cc
++++ b/absl/base/internal/sysinfo_test.cc
+@@ -37,17 +37,28 @@ TEST(SysinfoTest, NumCPUs) {
+ << "NumCPUs() should not have the default value of 0";
+ }
+
++// Ensure that NominalCPUFrequency returns a reasonable value, or 1.00 on
++// platforms where the CPU frequency is not available through sysfs.
++//
++// POWER is particularly problematic here; some Linux kernels expose the CPU
++// frequency, while others do not. Since we can't predict a priori what a given
++// machine is going to do, just disable this test on POWER on Linux.
++#if !(defined(__linux) && (defined(__ppc64__) || defined(__PPC64__)))
+ TEST(SysinfoTest, NominalCPUFrequency) {
+-#if !(defined(__aarch64__) && defined(__linux__)) && !defined(__EMSCRIPTEN__)
+- EXPECT_GE(NominalCPUFrequency(), 1000.0)
+- << "NominalCPUFrequency() did not return a reasonable value";
+-#else
+- // Aarch64 cannot read the CPU frequency from sysfs, so we get back 1.0.
+- // Emscripten does not have a sysfs to read from at all.
++ // Linux only exposes the CPU frequency on certain architectures, and
++ // Emscripten doesn't expose it at all.
++#if defined(__linux__) && \
++ (defined(__aarch64__) || defined(__hppa__) || defined(__mips__) || \
++ defined(__riscv) || defined(__s390x__)) || \
++ defined(__EMSCRIPTEN__)
+ EXPECT_EQ(NominalCPUFrequency(), 1.0)
+ << "CPU frequency detection was fixed! Please update unittest.";
++#else
++ EXPECT_GE(NominalCPUFrequency(), 1000.0)
++ << "NominalCPUFrequency() did not return a reasonable value";
+ #endif
+ }
++#endif
+
+ TEST(SysinfoTest, GetTID) {
+ EXPECT_EQ(GetTID(), GetTID()); // Basic compile and equality test.
--- /dev/null
+From: Benjamin Barenblat <bbaren@google.com>
+Subject: Remove endian-sensitivity from hash slow path
+Forwarded: yes
+Applied-Upstream: https://github.com/abseil/abseil-cpp/commit/9c6a50fdd80bb39fabd95faeda84f04062685ff3
+
+Prior to this commit, the Abseil hash fast path was endian-agnostic, but
+the slow path assumed a little-endian platform. Change the slow path to
+be endian-correct, ensuring that values produced by the fast and slow
+paths are equal even on big-endian systems.
+
+The author works at Google. Upstream applied this patch as Piper revision
+355424258 and exported it to GitHub; the Applied-Upstream URL above points to
+the exported commit.
+
+--- a/absl/hash/BUILD.bazel
++++ b/absl/hash/BUILD.bazel
+@@ -37,6 +37,7 @@ cc_library(name = "hash",
+ linkopts = ABSL_DEFAULT_LINKOPTS,
+ deps = [
+ ":city",
++ "//absl/base:config",
+ "//absl/base:core_headers",
+ "//absl/base:endian",
+ "//absl/container:fixed_array",
+--- a/absl/hash/CMakeLists.txt
++++ b/absl/hash/CMakeLists.txt
+@@ -25,6 +25,7 @@ absl_cc_library(NAME hash
+ COPTS
+ ${ABSL_DEFAULT_COPTS}
+ DEPS
++ absl::config
+ absl::core_headers
+ absl::endian
+ absl::fixed_array
+--- a/absl/hash/internal/hash.h
++++ b/absl/hash/internal/hash.h
+@@ -38,7 +38,8 @@
+ #include <utility>
+ #include <vector>
+
+-#include "absl/base/internal/endian.h"
++#include "absl/base/config.h"
++#include "absl/base/internal/unaligned_access.h"
+ #include "absl/base/port.h"
+ #include "absl/container/fixed_array.h"
+ #include "absl/meta/type_traits.h"
+@@ -804,26 +805,54 @@ class ABSL_DLL CityHashState
+ size_t len);
+
+ // Reads 9 to 16 bytes from p.
+- // The first 8 bytes are in .first, the rest (zero padded) bytes are in
+- // .second.
++ // The least significant 8 bytes are in .first, the rest (zero padded) bytes
++ // are in .second.
+ static std::pair<uint64_t, uint64_t> Read9To16(const unsigned char* p,
+ size_t len) {
+- uint64_t high = little_endian::Load64(p + len - 8);
+- return {little_endian::Load64(p), high >> (128 - len * 8)};
++ uint64_t low_mem = absl::base_internal::UnalignedLoad64(p);
++ uint64_t high_mem = absl::base_internal::UnalignedLoad64(p + len - 8);
++#ifdef ABSL_IS_LITTLE_ENDIAN
++ uint64_t most_significant = high_mem;
++ uint64_t least_significant = low_mem;
++#else
++ uint64_t most_significant = low_mem;
++ uint64_t least_significant = high_mem;
++#endif
++ return {least_significant, most_significant >> (128 - len * 8)};
+ }
+
+ // Reads 4 to 8 bytes from p. Zero pads to fill uint64_t.
+ static uint64_t Read4To8(const unsigned char* p, size_t len) {
+- return (static_cast<uint64_t>(little_endian::Load32(p + len - 4))
+- << (len - 4) * 8) |
+- little_endian::Load32(p);
++ uint32_t low_mem = absl::base_internal::UnalignedLoad32(p);
++ uint32_t high_mem = absl::base_internal::UnalignedLoad32(p + len - 4);
++#ifdef ABSL_IS_LITTLE_ENDIAN
++ uint32_t most_significant = high_mem;
++ uint32_t least_significant = low_mem;
++#else
++ uint32_t most_significant = low_mem;
++ uint32_t least_significant = high_mem;
++#endif
++ return (static_cast<uint64_t>(most_significant) << (len - 4) * 8) |
++ least_significant;
+ }
+
+ // Reads 1 to 3 bytes from p. Zero pads to fill uint32_t.
+ static uint32_t Read1To3(const unsigned char* p, size_t len) {
+- return static_cast<uint32_t>((p[0]) | //
+- (p[len / 2] << (len / 2 * 8)) | //
+- (p[len - 1] << ((len - 1) * 8)));
++ unsigned char mem0 = p[0];
++ unsigned char mem1 = p[len / 2];
++ unsigned char mem2 = p[len - 1];
++#ifdef ABSL_IS_LITTLE_ENDIAN
++ unsigned char significant2 = mem2;
++ unsigned char significant1 = mem1;
++ unsigned char significant0 = mem0;
++#else
++ unsigned char significant2 = mem0;
++ unsigned char significant1 = mem1;
++ unsigned char significant0 = mem2;
++#endif
++ return static_cast<uint32_t>(significant0 | //
++ (significant1 << (len / 2 * 8)) | //
++ (significant2 << ((len - 1) * 8)));
+ }
+
+ ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
--- /dev/null
+From: Benjamin Barenblat <bbaren@google.com>
+Subject: Remove endian-sensitivity from Abseil's RNG
+Forwarded: yes
+Applied-Upstream: https://github.com/abseil/abseil-cpp/commit/c36d825d9a5443f81d2656685ae021d6326da90c
+
+Ensure that the Abseil random number generator produces identical output
+on both big- and little-endian platforms by byte-swapping appropriately
+on big-endian systems.
+
+The author works at Google. Upstream applied this patch as Piper
+revision 355635051 and exported it to GitHub; the Applied-Upstream URL
+above points to the exported commit.
+
+--- a/absl/base/BUILD.bazel
++++ b/absl/base/BUILD.bazel
+@@ -479,6 +479,7 @@
+ copts = ABSL_DEFAULT_COPTS,
+ linkopts = ABSL_DEFAULT_LINKOPTS,
+ deps = [
++ ":base",
+ ":config",
+ ":core_headers",
+ ],
+--- a/absl/base/CMakeLists.txt
++++ b/absl/base/CMakeLists.txt
+@@ -418,6 +418,7 @@
+ COPTS
+ ${ABSL_DEFAULT_COPTS}
+ DEPS
++ absl::base
+ absl::config
+ absl::core_headers
+ PUBLIC
+--- a/absl/base/internal/endian.h
++++ b/absl/base/internal/endian.h
+@@ -26,6 +26,7 @@
+ #endif
+
+ #include <cstdint>
++#include "absl/base/casts.h"
+ #include "absl/base/config.h"
+ #include "absl/base/internal/unaligned_access.h"
+ #include "absl/base/port.h"
+@@ -173,6 +174,36 @@
+
+ #endif /* ENDIAN */
+
++inline uint8_t FromHost(uint8_t x) { return x; }
++inline uint16_t FromHost(uint16_t x) { return FromHost16(x); }
++inline uint32_t FromHost(uint32_t x) { return FromHost32(x); }
++inline uint64_t FromHost(uint64_t x) { return FromHost64(x); }
++inline uint8_t ToHost(uint8_t x) { return x; }
++inline uint16_t ToHost(uint16_t x) { return ToHost16(x); }
++inline uint32_t ToHost(uint32_t x) { return ToHost32(x); }
++inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
++
++inline int8_t FromHost(int8_t x) { return x; }
++inline int16_t FromHost(int16_t x) {
++ return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
++}
++inline int32_t FromHost(int32_t x) {
++ return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
++}
++inline int64_t FromHost(int64_t x) {
++ return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
++}
++inline int8_t ToHost(int8_t x) { return x; }
++inline int16_t ToHost(int16_t x) {
++ return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
++}
++inline int32_t ToHost(int32_t x) {
++ return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
++}
++inline int64_t ToHost(int64_t x) {
++ return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
++}
++
+ // Functions to do unaligned loads and stores in little-endian order.
+ inline uint16_t Load16(const void *p) {
+ return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
+@@ -233,6 +264,36 @@
+
+ #endif /* ENDIAN */
+
++inline uint8_t FromHost(uint8_t x) { return x; }
++inline uint16_t FromHost(uint16_t x) { return FromHost16(x); }
++inline uint32_t FromHost(uint32_t x) { return FromHost32(x); }
++inline uint64_t FromHost(uint64_t x) { return FromHost64(x); }
++inline uint8_t ToHost(uint8_t x) { return x; }
++inline uint16_t ToHost(uint16_t x) { return ToHost16(x); }
++inline uint32_t ToHost(uint32_t x) { return ToHost32(x); }
++inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
++
++inline int8_t FromHost(int8_t x) { return x; }
++inline int16_t FromHost(int16_t x) {
++ return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
++}
++inline int32_t FromHost(int32_t x) {
++ return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
++}
++inline int64_t FromHost(int64_t x) {
++ return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
++}
++inline int8_t ToHost(int8_t x) { return x; }
++inline int16_t ToHost(int16_t x) {
++ return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
++}
++inline int32_t ToHost(int32_t x) {
++ return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
++}
++inline int64_t ToHost(int64_t x) {
++ return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
++}
++
+ // Functions to do unaligned loads and stores in big-endian order.
+ inline uint16_t Load16(const void *p) {
+ return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
+--- a/absl/random/CMakeLists.txt
++++ b/absl/random/CMakeLists.txt
+@@ -611,6 +611,7 @@
+ ${ABSL_DEFAULT_LINKOPTS}
+ DEPS
+ absl::config
++ absl::endian
+ TESTONLY
+ )
+
+@@ -758,6 +759,7 @@
+ LINKOPTS
+ ${ABSL_DEFAULT_LINKOPTS}
+ DEPS
++ absl::endian
+ absl::random_internal_iostream_state_saver
+ absl::random_internal_randen
+ absl::raw_logging_internal
+@@ -1119,6 +1121,7 @@
+ LINKOPTS
+ ${ABSL_DEFAULT_LINKOPTS}
+ DEPS
++ absl::endian
+ absl::random_internal_randen_slow
+ gtest_main
+ )
+--- a/absl/random/internal/BUILD.bazel
++++ b/absl/random/internal/BUILD.bazel
+@@ -124,7 +124,10 @@
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ linkopts = ABSL_DEFAULT_LINKOPTS,
+- deps = ["//absl/base:config"],
++ deps = [
++ "//absl/base:config",
++ "//absl/base:endian",
++ ],
+ )
+
+ cc_library(
+@@ -241,6 +244,7 @@
+ deps = [
+ ":iostream_state_saver",
+ ":randen",
++ "//absl/base:endian",
+ "//absl/meta:type_traits",
+ ],
+ )
+@@ -606,6 +610,7 @@
+ ":platform",
+ ":randen_slow",
+ "@com_google_googletest//:gtest_main",
++ "//absl/base:endian",
+ ],
+ )
+
+--- a/absl/random/internal/explicit_seed_seq.h
++++ b/absl/random/internal/explicit_seed_seq.h
+@@ -23,6 +23,7 @@
+ #include <vector>
+
+ #include "absl/base/config.h"
++#include "absl/base/internal/endian.h"
+
+ namespace absl {
+ ABSL_NAMESPACE_BEGIN
+@@ -73,7 +74,7 @@
+ template <typename OutIterator>
+ void generate(OutIterator begin, OutIterator end) {
+ for (size_t index = 0; begin != end; begin++) {
+- *begin = state_.empty() ? 0 : state_[index++];
++ *begin = state_.empty() ? 0 : little_endian::FromHost32(state_[index++]);
+ if (index >= state_.size()) {
+ index = 0;
+ }
+--- a/absl/random/internal/randen_engine.h
++++ b/absl/random/internal/randen_engine.h
+@@ -23,6 +23,7 @@
+ #include <limits>
+ #include <type_traits>
+
++#include "absl/base/internal/endian.h"
+ #include "absl/meta/type_traits.h"
+ #include "absl/random/internal/iostream_state_saver.h"
+ #include "absl/random/internal/randen.h"
+@@ -76,7 +77,7 @@
+ impl_.Generate(state_);
+ }
+
+- return state_[next_++];
++ return little_endian::ToHost(state_[next_++]);
+ }
+
+ template <class SeedSequence>
+@@ -181,7 +182,8 @@
+ // In the case that `elem` is `uint8_t`, it must be cast to something
+ // larger so that it prints as an integer rather than a character. For
+ // simplicity, apply the cast all circumstances.
+- os << static_cast<numeric_type>(elem) << os.fill();
++ os << static_cast<numeric_type>(little_endian::FromHost(elem))
++ << os.fill();
+ }
+ os << engine.next_;
+ return os;
+@@ -200,7 +202,7 @@
+ // necessary to read a wider type and then cast it to uint8_t.
+ numeric_type value;
+ is >> value;
+- elem = static_cast<result_type>(value);
++ elem = little_endian::ToHost(static_cast<result_type>(value));
+ }
+ is >> next;
+ if (is.fail()) {
+--- a/absl/random/internal/randen_slow_test.cc
++++ b/absl/random/internal/randen_slow_test.cc
+@@ -17,6 +17,7 @@
+ #include <cstring>
+
+ #include "gtest/gtest.h"
++#include "absl/base/internal/endian.h"
+ #include "absl/random/internal/randen_traits.h"
+
+ namespace {
+@@ -56,7 +57,7 @@
+
+ uint64_t* id = d.state;
+ for (const auto& elem : kGolden) {
+- EXPECT_EQ(elem, *id++);
++ EXPECT_EQ(absl::little_endian::FromHost64(elem), *id++);
+ }
+ }
+
--- /dev/null
+From: John David Anglin <dave.anglin@bell.net>
+Subject: Fix build on hppa
+Bug-Debian: https://bugs.debian.org/971768
+Reviewed-by: Benjamin Barenblat <bbaren@debian.org>
+
+--- a/absl/base/internal/direct_mmap.h
++++ b/absl/base/internal/direct_mmap.h
+@@ -74,6 +74,7 @@
+ inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
+ off64_t offset) noexcept {
+ #if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) || \
++ (defined(__hppa__) && !defined(__LP64__)) || \
+ (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) || \
+ (defined(__PPC__) && !defined(__PPC64__)) || \
+ (defined(__riscv) && __riscv_xlen == 32) || \
+--- a/absl/debugging/internal/examine_stack.cc
++++ b/absl/debugging/internal/examine_stack.cc
+@@ -48,6 +48,8 @@
+ return reinterpret_cast<void*>(context->uc_mcontext.pc);
+ #elif defined(__arm__)
+ return reinterpret_cast<void*>(context->uc_mcontext.arm_pc);
++#elif defined(__hppa__)
++ return reinterpret_cast<void*>(context->uc_mcontext.sc_iaoq[0]);
+ #elif defined(__i386__)
+ if (14 < ABSL_ARRAYSIZE(context->uc_mcontext.gregs))
+ return reinterpret_cast<void*>(context->uc_mcontext.gregs[14]);
--- /dev/null
+From: Benjamin Barenblat <bbaren@google.com>
+Subject: Use libatomic if necessary
+Bug-Debian: https://bugs.debian.org/973492
+
+On some architectures, notably armel, Abseil needs symbols defined in
+libatomic. Abseil does not currently have a well-developed system to
+declare external library dependencies, so just have the linker determine
+if anything needs libatomic and add the DT_NEEDED entry where necessary.
+
+--- a/absl/copts/AbseilConfigureCopts.cmake
++++ b/absl/copts/AbseilConfigureCopts.cmake
+@@ -64,4 +64,8 @@
+ set(ABSL_TEST_COPTS "")
+ endif()
+
++list(APPEND ABSL_DEFAULT_LINKOPTS
++ "-Wl,--as-needed" "-latomic" "-Wl,--no-as-needed"
++)
++
+ set(ABSL_CXX_STANDARD "${CMAKE_CXX_STANDARD}")
--- /dev/null
+From: Benjamin Barenblat <bbaren@google.com>
+Subject: Avoid libgcc -NaN narrowing bug
+Forwarded: yes
+Applied-Upstream: https://github.com/abseil/abseil-cpp/commit/1bae23e32ba1f1af7c7d1488a69a351ec96dc98d
+
+When testing -NaN parsing, avoid narrowing -NaN from double to float. This
+avoids a bug in libgcc (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98251).
+
+The author works at Google. Upstream applied this patch as Piper revision
+347654751 and exported it to GitHub; the Applied-Upstream URL above points to
+the exported commit.
+
+--- a/absl/strings/charconv_test.cc
++++ b/absl/strings/charconv_test.cc
+@@ -653,7 +653,9 @@ TEST(FromChars, NaNFloats) {
+ negative_from_chars_float);
+ EXPECT_TRUE(std::signbit(negative_from_chars_float));
+ EXPECT_FALSE(Identical(negative_from_chars_float, from_chars_float));
+- from_chars_float = std::copysign(from_chars_float, -1.0);
++ // Use the (float, float) overload of std::copysign to prevent narrowing;
++ // see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98251.
++ from_chars_float = std::copysign(from_chars_float, -1.0f);
+ EXPECT_TRUE(Identical(negative_from_chars_float, from_chars_float));
+ }
+ }
--- /dev/null
+From: Samuel Benzaquen <sbenza@google.com>
+Subject: Fix float conversion for PPC.
+Origin: backport, https://github.com/abseil/abseil-cpp/commit/c36d825d9a5443f81d2656685ae021d6326da90c
+
+In PPC `long double` is a double-double representation which behaves weirdly
+wrt numeric_limits. Don't take `long double` into account when we are not
+handling `long double` natively anyway.
+
+Fix the convert test to always run the conversion even if we are not going to
+compare against libc's printf result. This allows exercising the code itself to
+make sure we don't trigger assertions or UB found by sanitizers.
+
+The author works at Google. Upstream applied this patch as Piper revision
+355857729 and exported it to GitHub; the Applied-Upstream URL above points to
+the exported commit.
+
+--- a/absl/strings/internal/str_format/convert_test.cc
++++ b/absl/strings/internal/str_format/convert_test.cc
+@@ -540,7 +540,8 @@
+ }
+
+ template <typename Floating>
+-void TestWithMultipleFormatsHelper(const std::vector<Floating> &floats) {
++void TestWithMultipleFormatsHelper(const std::vector<Floating> &floats,
++ const std::set<Floating> &skip_verify) {
+ const NativePrintfTraits &native_traits = VerifyNativeImplementation();
+ // Reserve the space to ensure we don't allocate memory in the output itself.
+ std::string str_format_result;
+@@ -588,7 +589,16 @@
+ AppendPack(&str_format_result, format, absl::MakeSpan(args));
+ }
+
+- if (string_printf_result != str_format_result) {
++#ifdef _MSC_VER
++ // MSVC has a different rounding policy than us so we can't test our
++ // implementation against the native one there.
++ continue;
++#elif defined(__APPLE__)
++ // Apple formats NaN differently (+nan) vs. (nan)
++ if (std::isnan(d)) continue;
++#endif
++ if (string_printf_result != str_format_result &&
++ skip_verify.find(d) == skip_verify.end()) {
+ // We use ASSERT_EQ here because failures are usually correlated and a
+ // bug would print way too many failed expectations causing the test
+ // to time out.
+@@ -602,12 +612,6 @@
+ }
+
+ TEST_F(FormatConvertTest, Float) {
+-#ifdef _MSC_VER
+- // MSVC has a different rounding policy than us so we can't test our
+- // implementation against the native one there.
+- return;
+-#endif // _MSC_VER
+-
+ std::vector<float> floats = {0.0f,
+ -0.0f,
+ .9999999f,
+@@ -621,7 +625,8 @@
+ std::numeric_limits<float>::epsilon(),
+ std::numeric_limits<float>::epsilon() + 1.0f,
+ std::numeric_limits<float>::infinity(),
+- -std::numeric_limits<float>::infinity()};
++ -std::numeric_limits<float>::infinity(),
++ std::nanf("")};
+
+ // Some regression tests.
+ floats.push_back(0.999999989f);
+@@ -650,21 +655,14 @@
+ std::sort(floats.begin(), floats.end());
+ floats.erase(std::unique(floats.begin(), floats.end()), floats.end());
+
+-#ifndef __APPLE__
+- // Apple formats NaN differently (+nan) vs. (nan)
+- floats.push_back(std::nan(""));
+-#endif
+-
+- TestWithMultipleFormatsHelper(floats);
++ TestWithMultipleFormatsHelper(floats, {});
+ }
+
+ TEST_F(FormatConvertTest, Double) {
+-#ifdef _MSC_VER
+- // MSVC has a different rounding policy than us so we can't test our
+- // implementation against the native one there.
+- return;
+-#endif // _MSC_VER
+-
++ // For values that we know won't match the standard library implementation we
++ // skip verification, but still run the algorithm to catch asserts/sanitizer
++ // bugs.
++ std::set<double> skip_verify;
+ std::vector<double> doubles = {0.0,
+ -0.0,
+ .99999999999999,
+@@ -678,7 +676,8 @@
+ std::numeric_limits<double>::epsilon(),
+ std::numeric_limits<double>::epsilon() + 1,
+ std::numeric_limits<double>::infinity(),
+- -std::numeric_limits<double>::infinity()};
++ -std::numeric_limits<double>::infinity(),
++ std::nan("")};
+
+ // Some regression tests.
+ doubles.push_back(0.99999999999999989);
+@@ -708,33 +707,29 @@
+ "5084551339423045832369032229481658085593321233482747978262041447231"
+ "68738177180919299881250404026184124858368.000000";
+
+- if (!gcc_bug_22142) {
+- for (int exp = -300; exp <= 300; ++exp) {
+- const double all_ones_mantissa = 0x1fffffffffffff;
+- doubles.push_back(std::ldexp(all_ones_mantissa, exp));
++ for (int exp = -300; exp <= 300; ++exp) {
++ const double all_ones_mantissa = 0x1fffffffffffff;
++ doubles.push_back(std::ldexp(all_ones_mantissa, exp));
++ if (gcc_bug_22142) {
++ skip_verify.insert(doubles.back());
+ }
+ }
+
+ if (gcc_bug_22142) {
+- for (auto &d : doubles) {
+- using L = std::numeric_limits<double>;
+- double d2 = std::abs(d);
+- if (d2 == L::max() || d2 == L::min() || d2 == L::denorm_min()) {
+- d = 0;
+- }
+- }
++ using L = std::numeric_limits<double>;
++ skip_verify.insert(L::max());
++ skip_verify.insert(L::min()); // NOLINT
++ skip_verify.insert(L::denorm_min());
++ skip_verify.insert(-L::max());
++ skip_verify.insert(-L::min()); // NOLINT
++ skip_verify.insert(-L::denorm_min());
+ }
+
+ // Remove duplicates to speed up the logic below.
+ std::sort(doubles.begin(), doubles.end());
+ doubles.erase(std::unique(doubles.begin(), doubles.end()), doubles.end());
+
+-#ifndef __APPLE__
+- // Apple formats NaN differently (+nan) vs. (nan)
+- doubles.push_back(std::nan(""));
+-#endif
+-
+- TestWithMultipleFormatsHelper(doubles);
++ TestWithMultipleFormatsHelper(doubles, skip_verify);
+ }
+
+ TEST_F(FormatConvertTest, DoubleRound) {
+@@ -1055,11 +1050,6 @@
+ }
+
+ TEST_F(FormatConvertTest, LongDouble) {
+-#ifdef _MSC_VER
+- // MSVC has a different rounding policy than us so we can't test our
+- // implementation against the native one there.
+- return;
+-#endif // _MSC_VER
+ const NativePrintfTraits &native_traits = VerifyNativeImplementation();
+ const char *const kFormats[] = {"%", "%.3", "%8.5", "%9", "%.5000",
+ "%.60", "%+", "% ", "%-10"};
+@@ -1120,10 +1110,18 @@
+ for (auto d : doubles) {
+ FormatArgImpl arg(d);
+ UntypedFormatSpecImpl format(fmt_str);
++ std::string result = FormatPack(format, {&arg, 1});
++
++#ifdef _MSC_VER
++ // MSVC has a different rounding policy than us so we can't test our
++ // implementation against the native one there.
++ continue;
++#endif // _MSC_VER
++
+ // We use ASSERT_EQ here because failures are usually correlated and a
+ // bug would print way too many failed expectations causing the test to
+ // time out.
+- ASSERT_EQ(StrPrint(fmt_str.c_str(), d), FormatPack(format, {&arg, 1}))
++ ASSERT_EQ(StrPrint(fmt_str.c_str(), d), result)
+ << fmt_str << " " << StrPrint("%.18Lg", d) << " "
+ << StrPrint("%La", d) << " " << StrPrint("%.1080Lf", d);
+ }
+--- a/absl/strings/internal/str_format/float_conversion.cc
++++ b/absl/strings/internal/str_format/float_conversion.cc
+@@ -98,12 +98,22 @@
+ return next_carry % divisor;
+ }
+
++constexpr bool IsDoubleDouble() {
++ // This is the `double-double` representation of `long double`.
++ // We do not handle it natively. Fallback to snprintf.
++ return std::numeric_limits<long double>::digits ==
++ 2 * std::numeric_limits<double>::digits;
++}
++
++using MaxFloatType =
++ typename std::conditional<IsDoubleDouble(), double, long double>::type;
++
+ // Generates the decimal representation for an integer of the form `v * 2^exp`,
+ // where `v` and `exp` are both positive integers.
+ // It generates the digits from the left (ie the most significant digit first)
+ // to allow for direct printing into the sink.
+ //
+-// Requires `0 <= exp` and `exp <= numeric_limits<long double>::max_exponent`.
++// Requires `0 <= exp` and `exp <= numeric_limits<MaxFloatType>::max_exponent`.
+ class BinaryToDecimal {
+ static constexpr int ChunksNeeded(int exp) {
+ // We will left shift a uint128 by `exp` bits, so we need `128+exp` total
+@@ -118,10 +128,10 @@
+ static void RunConversion(uint128 v, int exp,
+ absl::FunctionRef<void(BinaryToDecimal)> f) {
+ assert(exp > 0);
+- assert(exp <= std::numeric_limits<long double>::max_exponent);
++ assert(exp <= std::numeric_limits<MaxFloatType>::max_exponent);
+ static_assert(
+ StackArray::kMaxCapacity >=
+- ChunksNeeded(std::numeric_limits<long double>::max_exponent),
++ ChunksNeeded(std::numeric_limits<MaxFloatType>::max_exponent),
+ "");
+
+ StackArray::RunWithCapacity(
+@@ -218,14 +228,14 @@
+
+ // Converts a value of the form `x * 2^-exp` into a sequence of decimal digits.
+ // Requires `-exp < 0` and
+-// `-exp >= limits<long double>::min_exponent - limits<long double>::digits`.
++// `-exp >= limits<MaxFloatType>::min_exponent - limits<MaxFloatType>::digits`.
+ class FractionalDigitGenerator {
+ public:
+ // Run the conversion for `v * 2^exp` and call `f(generator)`.
+ // This function will allocate enough stack space to perform the conversion.
+ static void RunConversion(
+ uint128 v, int exp, absl::FunctionRef<void(FractionalDigitGenerator)> f) {
+- using Limits = std::numeric_limits<long double>;
++ using Limits = std::numeric_limits<MaxFloatType>;
+ assert(-exp < 0);
+ assert(-exp >= Limits::min_exponent - 128);
+ static_assert(StackArray::kMaxCapacity >=
+@@ -858,10 +868,10 @@
+ // This buffer holds the "0x1.ab1de3" portion of "0x1.ab1de3pe+2". Compute the
+ // size with long double which is the largest of the floats.
+ constexpr size_t kBufSizeForHexFloatRepr =
+- 2 // 0x
+- + std::numeric_limits<long double>::digits / 4 // number of hex digits
+- + 1 // round up
+- + 1; // "." (dot)
++ 2 // 0x
++ + std::numeric_limits<MaxFloatType>::digits / 4 // number of hex digits
++ + 1 // round up
++ + 1; // "." (dot)
+ char digits_buffer[kBufSizeForHexFloatRepr];
+ char *digits_iter = digits_buffer;
+ const char *const digits =
+@@ -1380,10 +1390,7 @@
+
+ bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv,
+ FormatSinkImpl *sink) {
+- if (std::numeric_limits<long double>::digits ==
+- 2 * std::numeric_limits<double>::digits) {
+- // This is the `double-double` representation of `long double`.
+- // We do not handle it natively. Fallback to snprintf.
++ if (IsDoubleDouble()) {
+ return FallbackToSnprintf(v, conv, sink);
+ }
+
--- /dev/null
+configure.diff
+fix-hppa.diff
+std-hash.diff
+latomic.diff
+cpu-frequency.diff
+nan-narrowing.diff
+endian-hash.diff
+endian-random.diff
+ppc-float-conversion.diff
--- /dev/null
+From: Benjamin Barenblat <bbaren@google.com>
+Subject: Work around broken std::hash on s390x
+Forwarded: no
+Bug-Debian: https://bugs.debian.org/977638
+
+On s390x, std::hash hashes large classes of data to the same value, which
+violates assumptions made by the Abseil tests. #ifdef out the test code that
+depends on those assumptions.
+
+--- a/absl/hash/hash_test.cc
++++ b/absl/hash/hash_test.cc
+@@ -358,6 +358,8 @@
+ TEST(HashValueTest, StdBitset) {
+ EXPECT_TRUE((is_hashable<std::bitset<257>>::value));
+
++ // The following assertions fail on s390x (https://bugs.debian.org/977638).
++#ifndef __s390x__
+ EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
+ {std::bitset<2>("00"), std::bitset<2>("01"), std::bitset<2>("10"),
+ std::bitset<2>("11")}));
+@@ -379,6 +381,7 @@
+ std::bitset<kNumBits>(bit_strings[3].c_str()),
+ std::bitset<kNumBits>(bit_strings[4].c_str()),
+ std::bitset<kNumBits>(bit_strings[5].c_str())}));
++#endif
+ } // namespace
+
+ template <typename T>
+@@ -400,10 +403,15 @@
+ }
+
+ REGISTER_TYPED_TEST_CASE_P(HashValueSequenceTest, BasicUsage);
++// std::vector<bool> tests fail on s390x, so exclude them. See
++// https://bugs.debian.org/977638.
+ using IntSequenceTypes =
+ testing::Types<std::deque<int>, std::forward_list<int>, std::list<int>,
+- std::vector<int>, std::vector<bool>, std::set<int>,
+- std::multiset<int>>;
++ std::vector<int>,
++#ifndef __s390x__
++ std::vector<bool>,
++#endif
++ std::set<int>, std::multiset<int>>;
+ INSTANTIATE_TYPED_TEST_CASE_P(My, HashValueSequenceTest, IntSequenceTypes);
+
+ // Private type that only supports AbslHashValue to make sure our chosen hash
--- /dev/null
+#!/usr/bin/make -f
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+export DEB_BUILD_MAINT_OPTIONS = hardening=+bindnow reproducible=+fixfilepath
+
+# Unit tests aren't working on all platforms yet.
+ifeq ($(shell dpkg-architecture -qDEB_HOST_ARCH),amd64)
+ABSL_RUN_TESTS=ON
+else
+ABSL_RUN_TESTS=OFF
+endif
+
+%:
+ dh $@
+
+override_dh_auto_clean:
+ $(RM) -r $(CURDIR)/static
+ $(RM) -r $(CURDIR)/shared
+
+override_dh_auto_configure:
+ dh_auto_configure -Bstatic -- -DCMAKE_CXX_STANDARD=14 -DBUILD_SHARED_LIBS=OFF
+ifeq ($(ABSL_RUN_TESTS),ON)
+ dh_auto_configure -Bshared -- -DCMAKE_CXX_STANDARD=14 -DBUILD_SHARED_LIBS=ON -DABSL_RUN_TESTS=ON -DABSL_USE_GOOGLETEST_HEAD=OFF
+else
+ dh_auto_configure -Bshared -- -DCMAKE_CXX_STANDARD=14 -DBUILD_SHARED_LIBS=ON
+endif
+
+override_dh_auto_build:
+ dh_auto_build -Bstatic
+ dh_auto_build -Bshared
+
+ifeq ($(ABSL_RUN_TESTS),ON)
+override_dh_auto_test:
+ dh_auto_test -Bshared
+endif
+
+override_dh_auto_install:
+ dh_auto_install -Bstatic
+ dh_auto_install -Bshared
+ find debian/tmp -type d -empty -delete
--- /dev/null
+3.0 (quilt)
--- /dev/null
+#!/bin/sh -eu
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+readonly TMP="$(mktemp -d)"
+trap "rm -rf \"$TMP\"" EXIT
+cd "$TMP"
+
+cat >test.cc <<EOF
+#include <absl/strings/numbers.h>
+
+int main(int argc, char* argv[]) {
+ int n;
+ if (!absl::SimpleAtoi(argv[1], &n)) {
+ return 1;
+ }
+ return n;
+}
+EOF
+
+cat >CMakeLists.txt <<EOF
+cmake_minimum_required(VERSION 3.5)
+project(test CXX)
+set(CMAKE_CXX_STANDARD 14)
+add_executable(test test.cc)
+find_package(absl REQUIRED)
+target_link_libraries(test absl::strings)
+EOF
+
+mkdir build
+cd build
+cmake ..
+make
+./test 0
--- /dev/null
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+Tests: smoke
+Depends: @, g++, libgtest-dev
+
+Tests: cmake
+Depends: @, cmake (>= 3.5), g++, make
--- /dev/null
+#!/bin/sh -eu
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+readonly TMP="$(mktemp -d)"
+trap "rm -rf \"$TMP\"" EXIT
+cd "$TMP"
+
+cat >smoke.cc <<EOF
+#include <absl/strings/str_join.h>
+#include <gtest/gtest.h>
+
+#include <vector>
+
+namespace {
+
+TEST(AbseilTest, StrJoinWorks) {
+ std::vector<std::string> v = {"foo", "bar", "baz"};
+ EXPECT_EQ(absl::StrJoin(v, "-"), "foo-bar-baz");
+}
+
+} // namespace
+EOF
+
+g++ -o smoke smoke.cc -labsl_strings -lgtest -lgtest_main -pthread
+./smoke
--- /dev/null
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+version=4
+opts=filenamemangle=s/.+\/v?(\d\S+)\.tar\.gz/abseil-$1\.tar\.gz/ \
+ https://github.com/abseil/abseil-cpp/releases .*/v?(\d\S+)\.tar\.gz
projects / abseil.git / commitdiff